general value, or `antlr-read-boolean' with ARGs = \(PROMPT TABLE) which
reads a boolean value or a member of TABLE. PROMPT is the prompt when
asking for a new value. If non-nil, TABLE is a table for completion or
-a function evaluating to such a table. The return value is quoted iff
+a function evaluating to such a table. The return value is quoted if
AS-STRING is non-nil and is either t or a symbol which is a member of
`antlr-options-style'.")
part \(CLASS-SPEC ...) in the result of `antlr-directory-dependencies'.
The result looks like \(OPTION WITH-UNKNOWN GLIB ...). OPTION is the
-complete \"-glib\" option. WITH-UNKNOWN has value t iff there is none
-or more than one grammar file for at least one super grammar.
+complete \"-glib\" option. WITH-UNKNOWN is t if there is none or more
+than one grammar file for at least one super grammar.
Each GLIB looks like \(GRAMMAR-FILE \. EVOCAB). GRAMMAR-FILE is a file
in which a super-grammar is defined. EVOCAB is the value of the export
(defun c-awk-get-NL-prop-prev-line (&optional do-lim)
;; Get the c-awk-NL-prop text-property from the previous line, calculating
- ;; it if necessary. Return nil iff we're already at BOB.
+ ;; it if necessary. Return nil if we're at BOB.
;; See c-awk-after-if-for-while-condition-p for a description of DO-LIM.
;;
;; This function might do hidden buffer changes.
;; Foo::Foo (int b) : Base (b) {}
;; car ^ ^ point
;;
- ;; The cdr of the return value is non-nil iff a
+ ;; The cdr of the return value is non-nil if a
;; `c-typedef-decl-kwds' specifier is found in the declaration,
;; i.e. the declared identifier(s) are types.
;;
(bq-process type)))))))))
(defun c-valid-offset (offset)
- "Return non-nil iff OFFSET is a valid offset for a syntactic symbol.
+ "Return non-nil if OFFSET is a valid offset for a syntactic symbol.
See `c-offsets-alist'."
(or (eq offset '+)
(eq offset '-)
(modify-syntax-entry starter (if (eq starter ?\\) "\\" ".") st)
(if ender (modify-syntax-entry ender "." st))))
;; i: have 2 args, after end of the first arg
- ;; i2: start of the second arg, if any (before delim iff `ender').
+ ;; i2: start of the second arg, if any (before delim if `ender').
;; ender: the last arg bounded by parens-like chars, the second one of them
;; starter: the starting delimiter of the first arg
;; go-forward: has 2 args, and the second part is empty
(defun cperl-beautify-regexp-piece (b e embed level)
;; b is before the starting delimiter, e before the ending
;; e should be a marker, may be changed, but remains "correct".
- ;; EMBED is nil iff we process the whole REx.
+ ;; EMBED is nil if we process the whole REx.
;; The REx is guaranteed to have //x
;; LEVEL shows how many levels deep to go
;; position at enter and at leave is not defined
(defun cpp-edit-toggle-known (arg)
"Toggle writable status for known conditionals.
-With optional argument ARG, make them writable iff ARG is positive."
+With optional argument ARG, make them writable if ARG is positive,
+otherwise make them unwritable."
(interactive "@P")
(if (or (and (null arg) cpp-known-writable)
(<= (prefix-numeric-value arg) 0))
(defun cpp-edit-toggle-unknown (arg)
"Toggle writable status for unknown conditionals.
-With optional argument ARG, make them writable iff ARG is positive."
+With optional argument ARG, make them writable if ARG is positive,
+otherwise make them unwritable."
(interactive "@P")
(if (or (and (null arg) cpp-unknown-writable)
(<= (prefix-numeric-value arg) 0))
(defvar tags-included-tables-function nil
"Function to do the work of `tags-included-tables' (which see).")
(defvar verify-tags-table-function nil
- "Function to return t iff current buffer contains valid tags file.")
+ "Function to return t if current buffer contains valid tags file.")
\f
;; Initialize the tags table in the current buffer.
-;; Returns non-nil iff it is a valid tags table. On
+;; Returns non-nil if it is a valid tags table. On
;; non-nil return, the tags table state variable are
;; made buffer-local and initialized to nil.
(defun initialize-new-tags-table ()
(defun tags-verify-table (file)
"Read FILE into a buffer and verify that it is a valid tags table.
Sets the current buffer to one visiting FILE (if it exists).
-Returns non-nil iff it is a valid table."
+Returns non-nil if it is a valid table."
(if (get-file-buffer file)
;; The file is already in a buffer. Check for the visited file
;; having changed since we last used it.
(verify-tags-table-function . etags-verify-tags-table)
))))
-;; Return non-nil iff the current buffer is a valid etags TAGS file.
(defun etags-verify-tags-table ()
+ "Return non-nil if the current buffer is a valid etags TAGS file."
;; Use eq instead of = in case char-after returns nil.
(eq (char-after (point-min)) ?\f))
;; From: ralf@up3aud1.gwdg.de (Ralf Fassel)
;; Test if TAB format continuation lines work.
(defun fortran-is-in-string-p (where)
- "Return non-nil iff WHERE (a buffer position) is inside a Fortran string."
+ "Return non-nil if WHERE (a buffer position) is inside a Fortran string."
(save-excursion
(goto-char where)
(cond
(defun gdb-many-windows (arg)
"Toggle the number of windows in the basic arrangement.
-With arg, display additional buffers iff arg is positive."
+With prefix argument ARG, display additional buffers if ARG is positive,
+otherwise use a single window."
(interactive "P")
(setq gdb-many-windows
(if (null arg)
(defun gdb-use-separate-io-buffer (arg)
"Toggle separate IO for debugged program.
-With arg, use separate IO iff arg is positive."
+With prefix argument ARG, use separate IO if ARG is positive,
+otherwise do not."
(interactive "P")
(setq gdb-use-separate-io-buffer
(if (null arg)
(defun gdb-speedbar-auto-raise (arg)
"Toggle automatic raising of the speedbar for watch expressions.
-With arg, automatically raise speedbar iff arg is positive."
+With prefix argument ARG, automatically raise speedbar if ARG is
+positive, otherwise don't automatically raise it."
(interactive "P")
(setq gdb-speedbar-auto-raise
(if (null arg)
(defun gdb-find-source-frame (arg)
"Toggle trying to find a source frame further up stack.
-With arg, look for a source frame further up stack iff arg is positive."
+With prefix argument ARG, look for a source frame further up
+stack if ARG is positive, otherwise don't look further up."
(interactive "P")
(setq gdb-find-source-frame
(if (null arg)
(defun gud-tooltip-dereference (&optional arg)
"Toggle whether tooltips should show `* expr' or `expr'.
-With arg, dereference expr iff arg is positive."
+With arg, dereference expr if ARG is positive, otherwise do not derereference."
(interactive "P")
(setq gud-tooltip-dereference
(if (null arg)
t -- open both code and comment blocks
nil -- open neither code nor comment blocks
-This has effect iff `search-invisible' is set to `open'."
+This has effect only if `search-invisible' is set to `open'."
:type '(choice (const :tag "open only code blocks" code)
(const :tag "open only comment blocks" comment)
(const :tag "open both code and comment blocks" t)
(goto-char (if repos-end end beg)))
(defun hs-hide-block-at-point (&optional end comment-reg)
- "Hide block iff on block beginning.
+ "Hide block if on block beginning.
Optional arg END means reposition at end.
Optional arg COMMENT-REG is a list of the form (BEGIN END) and
specifies the limits of the comment, or nil if the block is not
(goto-char maxp))
(defmacro hs-life-goes-on (&rest body)
- "Evaluate BODY forms iff variable `hs-minor-mode' is non-nil.
+ "Evaluate BODY forms if variable `hs-minor-mode' is non-nil.
In the dynamic context of this macro, `inhibit-point-motion-hooks'
and `case-fold-search' are both t."
`(when hs-minor-mode
(describe-function major-mode))
(defsubst octave-in-comment-p ()
- "Returns t if point is inside an Octave comment, nil otherwise."
+ "Return t if point is inside an Octave comment."
(interactive)
(save-excursion
(nth 4 (parse-partial-sexp (line-beginning-position) (point)))))
(defsubst octave-in-string-p ()
- "Returns t if point is inside an Octave string, nil otherwise."
+ "Return t if point is inside an Octave string."
(interactive)
(save-excursion
(nth 3 (parse-partial-sexp (line-beginning-position) (point)))))
(defsubst octave-not-in-string-or-comment-p ()
- "Returns t iff point is not inside an Octave string or comment."
+ "Return t if point is not inside an Octave string or comment."
(let ((pps (parse-partial-sexp (line-beginning-position) (point))))
(not (or (nth 3 pps) (nth 4 pps)))))
(defun octave-in-block-p ()
- "Returns t if point is inside an Octave block, nil otherwise.
+ "Return t if point is inside an Octave block.
The block is taken to start at the first letter of the begin keyword and
to end after the end keyword."
(let ((pos (point)))
(< pos (point)))))
(defun octave-in-defun-p ()
- "Returns t iff point is inside an Octave function declaration.
+ "Return t if point is inside an Octave function declaration.
The function is taken to start at the `f' of `function' and to end after
the end keyword."
(let ((pos (point)))
(error nil))))))))
(defun python-comment-line-p ()
- "Return non-nil iff current line has only a comment."
+ "Return non-nil if current line has only a comment."
(save-excursion
(end-of-line)
(when (eq 'comment (syntax-ppss-context (syntax-ppss)))
(looking-at (rx (or (syntax comment-start) line-end))))))
(defun python-blank-line-p ()
- "Return non-nil iff current line is blank."
+ "Return non-nil if current line is blank."
(save-excursion
(beginning-of-line)
(looking-at "\\s-*$")))
"Skip out of any nested brackets.
Skip forward if FORWARD is non-nil, else backward.
If SYNTAX is non-nil it is the state returned by `syntax-ppss' at point.
-Return non-nil iff skipping was done."
+Return non-nil if skipping was done."
(let ((depth (syntax-ppss-depth (or syntax (syntax-ppss))))
(forward (if forward -1 1)))
(unless (zerop depth)
(define-key map "\C-c\C-l" 'python-load-file)
(define-key map "\C-c\C-v" 'python-check)
;; Note that we _can_ still use these commands which send to the
- ;; Python process even at the prompt iff we have a normal prompt,
+ ;; Python process even at the prompt provided we have a normal prompt,
;; i.e. '>>> ' and not '... '. See the comment before
;; python-send-region. Fixme: uncomment these if we address that.
When Which Function mode is enabled, the current function name is
continuously displayed in the mode line, in certain major modes.
-With prefix ARG, turn Which Function mode on iff arg is positive,
+With prefix ARG, turn Which Function mode on if arg is positive,
and off otherwise."
:global t :group 'which-func
(if which-function-mode
(sleep-for 1)))
(defun xscheme-process-running-p ()
- "True iff there is a Scheme process whose status is `run'."
+ "True if there is a Scheme process whose status is `run'."
(let ((process (get-process xscheme-process-name)))
(and process
(eq (process-status process) 'run))))
(and buffer (get-buffer-window buffer))))
(defun xscheme-process-buffer-current-p ()
- "True iff the current buffer is the Scheme process buffer."
+ "True if the current buffer is the Scheme process buffer."
(eq (xscheme-process-buffer) (current-buffer)))
\f
;;;; Process Filter Operations
projects / emacs.git / commitdiff